/*
 * ActualizacionesHelper.java
 *
 * Created on 16 de marzo de 2007, 02:57 PM
 *
 * To change this template, choose Tools | Options and locate the template under
 * the Source Creation and Management node. Right-click the template and choose
 * Open. You can then make changes to the template in the Source Editor.
 */

package com.src.computec.radar.services.utilities.actualizaciones.helper;

import com.src.computec.radar.base.dao.exception.DAOException;
import com.src.computec.radar.base.source.CoreSource;
import com.src.computec.radar.base.util.RandomStringUtils;
import com.src.computec.radar.services.base.constantes.ConstantesGenerales;
import com.src.computec.radar.services.source.CoreServicesSource;
import com.src.computec.radar.services.utilities.actualizaciones.exception.ActualizacionesException;
import com.src.computec.radar.services.utilities.base.helper.BaseHelper;
import com.src.computec.radar.services.utilities.dao.BaseBaseEmDAO;
import com.src.computec.radar.services.utilities.dao.BaseEnvioDAO;
import com.src.computec.radar.services.utilities.dao.BaseFileManagerDAO;
import com.src.computec.radar.services.utilities.dao.BaseInformesDAO;
import com.src.computec.radar.services.utilities.dao.BaseInsertoDAO;
import com.src.computec.radar.services.utilities.dto.BaseExcelDto;
import com.src.computec.radar.services.utilities.dto.EnvioDto;
import com.src.computec.radar.services.utilities.dto.FileManagerDto;
import com.src.computec.radar.services.utilities.dto.NodoDto;
import com.src.computec.radar.services.utilities.dto.UsuarioPortalWasDto;
import com.src.computec.radar.services.utilities.zip.CreateZipFile;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFCellStyle;
import org.apache.poi.hssf.usermodel.HSSFFont;
import org.apache.poi.hssf.usermodel.HSSFRichTextString;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.util.HSSFColor;

/**
 *
 * @author aocampo
 */
public class ActualizacionesHelper extends BaseHelper {
    
    /** Creates a new instance of ActualizacionesHelper */
    public ActualizacionesHelper() {
    }
    
    public void insertUsuarioPortalWas(UsuarioPortalWasDto dto) throws ActualizacionesException {
        BaseInformesDAO dao = (BaseInformesDAO) this.getFactoryDAO().getInformesDAO();
        try {
            dao.insertUsuarioPortalWas(dto);
        }
        catch (DAOException e) {
            throw new ActualizacionesException("ActualizacionesHelper:insertUsuarioPortalWas: " + e.toString());
        }
    }
    
    public void updateInsertos(List insertos) throws ActualizacionesException {
        BaseInsertoDAO dao = (BaseInsertoDAO) this.getFactoryDAO().getInsertoDAO();
        try {
            dao.updateInsertos(insertos);
        }
        catch (DAOException e) {
            throw new ActualizacionesException("ActualizacionesHelper:updateInsertos: " + e.toString());
        }
    }
    
    public void insertFileManager(FileManagerDto dto) throws ActualizacionesException {
        BaseFileManagerDAO dao = (BaseFileManagerDAO) this.getFactoryDAO().getFileManagerDAO();
        try {
            dao.insertFileManager(dto);
        }
        catch (DAOException e) {
            throw new ActualizacionesException("ActualizacionesHelper:insertFileManager: " + e.toString());
        }
    }
    
    public void insertFileManagerKey(FileManagerDto dto) throws ActualizacionesException {
        BaseFileManagerDAO dao = (BaseFileManagerDAO) this.getFactoryDAO().getFileManagerDAO();
        try {
            dao.insertFileManagerKey(dto);
        }
        catch (DAOException e) {
            throw new ActualizacionesException("ActualizacionesHelper:insertFileManagerKey: " + e.toString());
        }
    }
	
    public Hashtable updateGestionEnvios(List envios, String codigoGestion, String responsable) throws ActualizacionesException {
        BaseEnvioDAO dao = (BaseEnvioDAO) this.getFactoryDAO().getEnvioDAO();
	Hashtable hashRet_=new Hashtable();
        try {
            hashRet_= dao.updateGestionEnvios(envios, codigoGestion, responsable);
	    ArrayList listOrdenes_=(ArrayList)hashRet_.get("ORDENES");
	    if(listOrdenes_!=null){
		ConstantesGenerales.getInstance();
		String tipoBase_=ConstantesGenerales.TIPO_BASE_EM_NORMAL;
		for(Iterator it=listOrdenes_.iterator();it.hasNext();){
		    String numOrden_=(String)it.next();
		    
			this.generarBaseXNumOrden(numOrden_,tipoBase_);
		    
		}		
	    }
	    return hashRet_;
        }
        catch (DAOException e) {
            throw new ActualizacionesException("ActualizacionesHelper:updateGestionEnvios: " + e.toString());
        }
    }

    public Hashtable updateGestionEnvios(String codigoInicio, String codigoFinal, String codigoGestion, String responsable) throws ActualizacionesException {
        BaseEnvioDAO dao = (BaseEnvioDAO) this.getFactoryDAO().getEnvioDAO();
	Hashtable hashRet_=new Hashtable();
        try {
            hashRet_=dao.updateGestionEnvios(codigoInicio, codigoFinal, codigoGestion, responsable);
	    ArrayList listOrdenes_=(ArrayList)hashRet_.get("ORDENES");
	//    System.out.println("LIST SIZE:"+listOrdenes_.size());
	    if(listOrdenes_!=null){
		ConstantesGenerales.getInstance();
		String tipoBase_=ConstantesGenerales.TIPO_BASE_EM_NORMAL;
		for(Iterator it=listOrdenes_.iterator();it.hasNext();){
		    String numOrden_=(String)it.next();		    
			this.generarBaseXNumOrden(numOrden_, tipoBase_);		    
		}		
	    }
	    
	    return hashRet_;
        }
        catch (DAOException e) {
            throw new ActualizacionesException("ActualizacionesHelper:updateGestionEnvios: " + e.toString());
        }
    }
    
    
    /*****************************************************************/
    /** Base Empresas de Mensajeria
     *****************************************************************/
    
     public int insertBaseEm(String pDesc,String path,String pNumOrden,String pCodigoNodo,String pCantReg,String pTipoBase) throws ActualizacionesException{     
	BaseBaseEmDAO dao = (BaseBaseEmDAO) this.getFactoryDAO().getBaseEmDAO();
	try{
	     return dao.insertBaseEm(pDesc, path, pNumOrden, pCodigoNodo, pCantReg, pTipoBase);
        }catch(DAOException e){
	   throw new ActualizacionesException("ActualizacionesHelper:insertBaseEm: " + e.toString());
	} 
    }
    
    
    
   public boolean[] generarBaseXNumOrden(final String pNumOrden,String pTipoBase) throws ActualizacionesException{
       
	final BaseBaseEmDAO dao = (BaseBaseEmDAO) this.getFactoryDAO().getBaseEmDAO();
	boolean generar_=this.validarCreacionBase(pNumOrden, pTipoBase);
	boolean existe_=false;
	try{
	    existe_=dao.existeNumOrden(pNumOrden);
	}catch(DAOException dax){
	    dax.printStackTrace();
	}
	boolean[] retGeneracion=new boolean[3];
	retGeneracion[0]=generar_ && existe_;
	retGeneracion[1]=!generar_ && existe_;
	retGeneracion[2]=existe_;
	if(generar_ && existe_){
	     Thread th=new Thread(new Runnable(){
		public void run(){			 
		    try{

			  List listNodos_=dao.getNodosXNumOrden(pNumOrden);
			  for(Iterator it=listNodos_.iterator();it.hasNext();){
			      NodoDto nodo_=(NodoDto)it.next();
			      String codigoNodo_=nodo_.getCodigoNodo();
			      generarBaseEmXNodo(pNumOrden, codigoNodo_);
			  }
		    }catch(DAOException e){
			e.printStackTrace();
			 // throw new BaseEmException("BaseEmHelper:generarBaseEmXNodo: " + e.toString());
		    }catch(ActualizacionesException bex){
			bex.printStackTrace();
		    }
		}   
	    },pNumOrden);
	    th.start();
	}
	return retGeneracion;
   } 
    
   public void generarBaseReasignacion(final String pCodigoEvaluacion,final String pReasignacionAplicada) throws ActualizacionesException{
       
	final BaseBaseEmDAO dao = (BaseBaseEmDAO) this.getFactoryDAO().getBaseEmDAO();
	final String strReasig_=ConstantesGenerales.DESC_BASE_EM_REASIG;
	final String pCodigoBase=ConstantesGenerales.TIPO_BASE_EM_REASIG;
	 Thread th=new Thread(new Runnable(){
	    public void run(){			 
		try{

		      //List listBaseReasig_=dao.getBaseReasignacion(pCodReasigna, pCodigoEvaluacion, pReasignacionAplicada);
		    List listXGenerar_=dao.getListaXGenerarBase(pCodigoEvaluacion, pReasignacionAplicada);
		    if(listXGenerar_.size()>0){
			for(Iterator it=listXGenerar_.iterator();it.hasNext();){
			    EnvioDto dto_=(EnvioDto)it.next();
			    String numOrden_=dto_.getNumeroOrden();
			    String codigoNodo_=dto_.getCodigoNodo();
			
			    List listBaseReasig_=dao.getBaseReasignacion(numOrden_,codigoNodo_,pCodigoEvaluacion, pReasignacionAplicada);
			    if(listBaseReasig_.size()>0){
				crearExcelBase(listBaseReasig_, numOrden_,codigoNodo_,strReasig_,pCodigoBase);  
			    }
			}
		    }
		    
		    dao.updateReasignacionesGeneradas(pCodigoEvaluacion, pReasignacionAplicada);
		}catch(DAOException e){
		    e.printStackTrace();
		     // throw new BaseEmException("BaseEmHelper:generarBaseEmXNodo: " + e.toString());
		}catch(ActualizacionesException bex){
		    bex.printStackTrace();
		}catch(IOException iox){
		    iox.printStackTrace();
		}
	    }   
	});
	
	th.start();
   } 
    
   
   public void generarBaseEmRetenidos(final String enviosNoClas,final String enviosClas,final String pCodigoResponsable) throws ActualizacionesException {
         
	   final BaseBaseEmDAO dao = (BaseBaseEmDAO) this.getFactoryDAO().getBaseEmDAO();
	   if((enviosNoClas!=null && !enviosNoClas.trim().equals("")) || (enviosClas!=null && !enviosNoClas.trim().equals(""))){
		Thread th=new Thread(new Runnable(){
		   public void run(){			 
			   try {
			    HashMap hashPorGenerar_ = null;
			    if(enviosClas!=null && !enviosClas.trim().equals("")){
				hashPorGenerar_ = dao.getBaseEmXCodBarras(enviosClas,pCodigoResponsable);
			    }
			    if(enviosNoClas!=null && !enviosNoClas.trim().equals("")){
				dao.actualizaEstadoARetenidos(enviosNoClas,pCodigoResponsable);
			    }			    
			    if(hashPorGenerar_!=null && hashPorGenerar_.size()>=1){

				ConstantesGenerales.getInstance();
				String strNoClass=ConstantesGenerales.DESC_BASE_EM_NOCLASS;
				String codigoBase_=ConstantesGenerales.TIPO_BASE_EM_NOCLASS;

				for(Iterator itHash=hashPorGenerar_.keySet().iterator();itHash.hasNext();){
				    String key_=(String)itHash.next();
				    ArrayList baseList_=(ArrayList)hashPorGenerar_.get(key_);		
				    String[] splitArray_=key_.split("-");				
				    if(splitArray_.length==2 && baseList_.size()>0){
					String numOrden_=splitArray_[0];
					String codigoNodo_=splitArray_[1];
					crearExcelBase(baseList_, numOrden_, codigoNodo_, strNoClass,codigoBase_);
				    }
				}		
			    }
			}
			catch (Exception e) {
			   // throw new ActualizacionesException("ActualizacionesHelper:generarBaseEmRetenidos: " + e.toString());
			}
		    }   
		});
		th.start();
	}
   }  
   
   
   private void generarBaseEmXNodo(String pNumOrden,String pCodigoNodo) throws ActualizacionesException{
	  BaseBaseEmDAO dao = (BaseBaseEmDAO) this.getFactoryDAO().getBaseEmDAO();
	  
	  String strNormal_=ConstantesGenerales.DESC_BASE_EM_NORMAL;
	  ConstantesGenerales.getInstance();
	  String pCodigoBase=ConstantesGenerales.TIPO_BASE_EM_NORMAL;
	  
	  try{	   
	      if(!pCodigoNodo.equals("0")){
		  List base_=dao.getBase(pNumOrden, pCodigoNodo);		    
		  if(base_.size()>0){
		    this.crearExcelBase(base_, pNumOrden,pCodigoNodo, strNormal_, pCodigoBase);
		  }
	      }
	      
	  }catch(DAOException e){
	      e.printStackTrace();
	      throw new ActualizacionesException("ActualizacionesHelper:generarBaseEmXNodo: " + e.toString());
	  }catch(IOException iox){
	      iox.printStackTrace();
	      throw new ActualizacionesException("ActualizacionesHelper:generarBaseEmXNodo: " + iox.toString());
	  }catch(Exception e){
	      e.printStackTrace();
	  }
    }
   
  public boolean validarCreacionBase(String pNumOrden,String pTipoBase) throws ActualizacionesException{
	  BaseBaseEmDAO dao = (BaseBaseEmDAO) this.getFactoryDAO().getBaseEmDAO();
	  boolean debeCrearseBase_=true;	  
	  try{
	      String numOrden_=dao.validarBaseCreadaXNumOrden(pNumOrden, pTipoBase);
	      boolean existThread_=false;
	      if(numOrden_.equals("")){
		  int numThreads;
		  
		  Thread[] listOfThreads;
		  Thread parent_ =Thread.currentThread();
		  ThreadGroup gr= parent_.getThreadGroup();
		  numThreads = gr.activeCount();
		  listOfThreads = new Thread[numThreads];
		  gr.enumerate(listOfThreads);
		  for(int i=0; i< numThreads;i++){
		      boolean thbool=listOfThreads[i].getName().equals(numOrden_);
		      existThread_=existThread_&&thbool;		      
		  }
		  debeCrearseBase_=!existThread_;
	      }else{
		  debeCrearseBase_=false;
	      }
	  }catch(DAOException e){e.printStackTrace();
	      throw new ActualizacionesException("ActualizacionesHelper:validarCreacionBase: " + e.toString());
	  }
	  return debeCrearseBase_;
    }
      
   public void crearExcelBase(List pCto,String pNumOrden,String pCodigoNodo,String pTipoBase,String pCodigoBase) throws ActualizacionesException,IOException
   {
	
        Date date_=new Date(System.currentTimeMillis());
        DateFormat formatter ;
        formatter = new SimpleDateFormat("dd/MMM/yyyy");
        
        HSSFWorkbook workbookArchivo = new HSSFWorkbook();
	FileOutputStream outputStreamArchivo =null;
	ArrayList zipArray=new ArrayList();
	
	int rownum =  0;
	
	HSSFCellStyle styleHeader=null;
	HSSFCellStyle styleRow =null;
	 // Create a new sheet
	HSSFSheet sheetArchivo = null;
	// Declare a row object reference
	HSSFRow rowArchivo = null;
	// Declare a cell object reference
	HSSFCell cellArchivo = null;
	int numHoja_=1;
	HashMap numRegHash_=new HashMap();

	for (Iterator iter_ = pCto.iterator(); iter_.hasNext(); )
        {	    
	 
	    if(rownum==0 || rownum>=50000){
		if(rownum>=50000){
		    
		    workbookArchivo.write(outputStreamArchivo);
		    outputStreamArchivo.close();
		    
		    numRegHash_.put(new Integer(numHoja_), new Integer(rownum));
		 
		    workbookArchivo = new HSSFWorkbook();
		  
		     numHoja_++;
		}
		
		String nameArchivo="Base_"+RandomStringUtils.randomAlphanumeric(10)+".xls";        
		String pathArchivo = ConstantesGenerales.PATH_ARCHIVOS_BASE+nameArchivo;     
	//	System.out.println("CREAR ARCHIVO:" + CoreSource.getInstance().getUtilidadesSetupKey("folderCargueArchivos")+pathArchivo);

		
		// Create a new file
	//      FileOutputStream outputStreamArchivo = new FileOutputStream("C:\\CargueArchivos\\"+pathArchivo);      
		outputStreamArchivo = new FileOutputStream(CoreSource.getInstance().getUtilidadesSetupKey("folderCargueArchivos")+pathArchivo); 
		File toZip=new File(CoreSource.getInstance().getUtilidadesSetupKey("folderCargueArchivos")+pathArchivo);
		zipArray.add(toZip);
		
		// Create a new workbook
	    
	    
	    
	    
	    ////////////////////////////////////////////////////////////////////////////////////////////////////
	    ///////                   Graba los encabezados del archivo de inconsistencias            //////////
	    ////////////////////////////////////////////////////////////////////////////////////////////////////


	styleHeader = workbookArchivo.createCellStyle();
	//styleHeader.setDataFormat(HSSFDataFormat.getBuiltinFormat("($#,##0_);[Red]($#,##0)"));
	styleHeader.setFillBackgroundColor(HSSFColor.LIGHT_GREEN.index);
	styleHeader.setBorderBottom(HSSFCellStyle.BORDER_MEDIUM);
	styleHeader.setBorderLeft(HSSFCellStyle.BORDER_MEDIUM);  
	styleHeader.setBorderRight(HSSFCellStyle.BORDER_MEDIUM);    
	styleHeader.setBorderTop(HSSFCellStyle.BORDER_MEDIUM);
	styleHeader.setVerticalAlignment(HSSFCellStyle.VERTICAL_CENTER);   
	//styleHeader.setFillForegroundColor(HSSFColor.LIGHT_GREEN.index);  
	//styleHeader.setFillPattern(HSSFCellStyle.SOLID_FOREGROUND);
	styleHeader.setAlignment(HSSFCellStyle.ALIGN_CENTER);


	styleRow = workbookArchivo.createCellStyle();   
	styleRow.setBorderBottom(HSSFCellStyle.BORDER_THIN);
	styleRow.setBorderLeft(HSSFCellStyle.BORDER_THIN);  
	styleRow.setBorderRight(HSSFCellStyle.BORDER_THIN);    
	styleRow.setBorderTop(HSSFCellStyle.BORDER_THIN); 

	HSSFCellStyle styleRowBold = workbookArchivo.createCellStyle();   
	styleRowBold.setBorderBottom(HSSFCellStyle.BORDER_THIN);
	styleRowBold.setBorderLeft(HSSFCellStyle.BORDER_THIN);  
	styleRowBold.setBorderRight(HSSFCellStyle.BORDER_THIN);    
	styleRowBold.setBorderTop(HSSFCellStyle.BORDER_THIN); 

	HSSFFont fontRowNormalBold = workbookArchivo.createFont();
	fontRowNormalBold.setBoldweight(HSSFFont.BOLDWEIGHT_BOLD);
	fontRowNormalBold.setColor(HSSFColor.BLACK.index);
	styleRowBold.setFont(fontRowNormalBold);
	styleHeader.setFont(fontRowNormalBold);
     
        
	HSSFCellStyle currentStyle=styleRow;
	
	//System.out.println("SIZE:"+pCto.size());
	
        
	    
	    
		rownum= 0;
		    sheetArchivo = workbookArchivo.createSheet("BASE-"+numHoja_);
		  //  numHoja_++;
		    rowArchivo = sheetArchivo.createRow(rownum);

		 int indx=0;

		 sheetArchivo.setColumnWidth((short)indx++, (short) (256*40));     
		// sheetArchivo.setColumnWidth((short)indx++, (short) (256*25));  
		 sheetArchivo.setColumnWidth((short)indx++, (short) (256*35));
		 sheetArchivo.setColumnWidth((short)indx++, (short) (256*45));
		 sheetArchivo.setColumnWidth((short)indx++, (short) (256*45));
		 sheetArchivo.setColumnWidth((short)indx++, (short) (256*35));
		 sheetArchivo.setColumnWidth((short)indx++, (short) (256*25));
		 sheetArchivo.setColumnWidth((short)indx++, (short) (256*25));
		 sheetArchivo.setColumnWidth((short)indx++, (short) (256*20));
		 sheetArchivo.setColumnWidth((short)indx++, (short) (256*30));
		 sheetArchivo.setColumnWidth((short)indx++, (short) (256*30));
		 


		 indx=0;
		    cellArchivo = rowArchivo.createCell( (short)indx++ );
		    cellArchivo.setCellStyle(styleHeader);
		    cellArchivo.setCellValue( new HSSFRichTextString("NODO"));	
		    
		    /*cellArchivo = rowArchivo.createCell( (short)indx++ );
		    cellArchivo.setCellStyle(styleHeader);		    
		    cellArchivo.setCellValue( new HSSFRichTextString("CODIGO INT.CLIENTE"));
		    */
		    cellArchivo = rowArchivo.createCell( (short)indx++ );
		    cellArchivo.setCellStyle(styleHeader);
		    cellArchivo.setCellValue( new HSSFRichTextString("CLIENTE"));
		    
		    cellArchivo = rowArchivo.createCell( (short)indx++ );
		    cellArchivo.setCellStyle(styleHeader);
		    cellArchivo.setCellValue( new HSSFRichTextString("PRODUCTO"));
		    
		    cellArchivo = rowArchivo.createCell( (short) indx++);
		    cellArchivo.setCellStyle(styleHeader);
		    cellArchivo.setCellValue( new HSSFRichTextString("# ORDEN"));

		    cellArchivo = rowArchivo.createCell( (short)indx++ );
		    cellArchivo.setCellStyle(styleHeader);
		    cellArchivo.setCellValue( new HSSFRichTextString("CONSECUTIVO"));

		    cellArchivo = rowArchivo.createCell( (short)indx++ );
		    cellArchivo.setCellStyle(styleHeader);
		    cellArchivo.setCellValue( new HSSFRichTextString("CODIGO BARRAS"));
		    cellArchivo = rowArchivo.createCell( (short)indx++ );
		    cellArchivo.setCellStyle(styleHeader);
		    cellArchivo.setCellValue( new HSSFRichTextString("DIRECCION"));
		    cellArchivo = rowArchivo.createCell( (short)indx++ );
		    cellArchivo.setCellStyle(styleHeader);
		    cellArchivo.setCellValue( new HSSFRichTextString("DEPARTAMENTO"));
		    cellArchivo = rowArchivo.createCell( (short)indx++ );
		    cellArchivo.setCellStyle(styleHeader);
		    cellArchivo.setCellValue( new HSSFRichTextString("MUNICIPIO/CENTRO POBLADO"));

		    cellArchivo = rowArchivo.createCell( (short)indx++ );
		    cellArchivo.setCellStyle(styleHeader);
		    cellArchivo.setCellValue( new HSSFRichTextString("ZONA"));

		    
		    rownum++;
	    }


	    //System.out.println("FILA:"+rownum);
	    
	    
	    BaseExcelDto dto_=(BaseExcelDto)iter_.next();	    	  
		
            rowArchivo = sheetArchivo.createRow(rownum);                      
            // Create a cell
            int index_=0;
            cellArchivo = rowArchivo.createCell((short)index_++);         
            cellArchivo.setCellValue(new HSSFRichTextString(dto_.getNombreNodo()));
           // cellArchivo.setCellStyle(currentStyle);
	    
	//    cellArchivo = rowArchivo.createCell((short)index_++);         
          //  cellArchivo.setCellValue(new HSSFRichTextString(dto_.getCodigoInternoCli()));
        //    cellArchivo.setCellStyle(currentStyle);
            
	    cellArchivo = rowArchivo.createCell((short)index_++);         
            cellArchivo.setCellValue(new HSSFRichTextString(dto_.getClienteRazonSoc()));
          //  cellArchivo.setCellStyle(currentStyle);
	    
	    cellArchivo = rowArchivo.createCell((short)index_++);         
            cellArchivo.setCellValue(new HSSFRichTextString(dto_.getDescProducto()));
        //    cellArchivo.setCellStyle(currentStyle);
	    
	    
	    cellArchivo = rowArchivo.createCell((short)index_++);         
            cellArchivo.setCellValue(new HSSFRichTextString(Integer.toString(dto_.getNumOrden())));
       //     cellArchivo.setCellStyle(currentStyle);
	    
		    
	    cellArchivo = rowArchivo.createCell((short)index_++);         
            cellArchivo.setCellValue(new HSSFRichTextString(Integer.toString(dto_.getConsecutivoEnvio())));
       //     cellArchivo.setCellStyle(currentStyle);
	    
	    cellArchivo = rowArchivo.createCell((short)index_++);         
            cellArchivo.setCellValue(new HSSFRichTextString(dto_.getCodBarras()));
       //     cellArchivo.setCellStyle(currentStyle);
	    
	    
	    cellArchivo = rowArchivo.createCell((short)index_++);         
            cellArchivo.setCellValue(new HSSFRichTextString(dto_.getDireccion()));
        //    cellArchivo.setCellStyle(currentStyle);
	    
	    cellArchivo = rowArchivo.createCell((short)index_++);         
            cellArchivo.setCellValue(new HSSFRichTextString(dto_.getDepartamento()));
           // cellArchivo.setCellStyle(currentStyle);
	    
	    cellArchivo = rowArchivo.createCell((short)index_++);         
            cellArchivo.setCellValue(new HSSFRichTextString(dto_.getMunicipio()+"/"+dto_.getCentroPoblado()));
      //      cellArchivo.setCellStyle(currentStyle);
	    
	    cellArchivo = rowArchivo.createCell((short)index_++);         
            cellArchivo.setCellValue(new HSSFRichTextString(dto_.getZona()));
        //    cellArchivo.setCellStyle(currentStyle);
	 
	    
	    rownum++;
	
	   
	  
        }
	    numRegHash_.put(new Integer(numHoja_), new Integer(rownum));
	  
	    workbookArchivo.write(outputStreamArchivo);
	    outputStreamArchivo.close();
		    
		    
	    int totalZips=zipArray.size();
	    int part=1;
		    
	
	
	for(Iterator it=zipArray.iterator();it.hasNext();)	    {
	    String nameArchivo="ZIP_"+RandomStringUtils.randomAlphanumeric(10)+".zip";        
	    String pathArchivo = ConstantesGenerales.PATH_ARCHIVOS_BASE+nameArchivo;   
	    File zipPath=new File(CoreSource.getInstance().getUtilidadesSetupKey("folderCargueArchivos")+pathArchivo);
	    zipPath.createNewFile();
	  
	    CreateZipFile zipper=new CreateZipFile();
	    
	    zipper.createZipArchive(zipPath, (File)it.next());
	   
	   Integer numRegH_=(Integer)numRegHash_.get(new Integer(part));
	   
	    
	    
//	    try{
	       this.insertBaseEm(pTipoBase+" "+part+" de "+totalZips  , pathArchivo, pNumOrden, pCodigoNodo, Integer.toString(numRegH_.intValue()-1),pCodigoBase);
	       
	        part++;
//	    }catch(OrdenProcesoException oex){
//		oex.printStackTrace();
//		this.setMensajeAlert("error", "Error", ConsultasSource.getInstance().getConsultasMessagesSetupKey("ErrorSistema"), true);
//		this.getSessionBeanEstadoOrdenProceso().setRenderedMensajeAlertGridPanel(true);
//	    }catch(Exception ex){
//		ex.printStackTrace();
//		this.setMensajeAlert("error", "Error", ConsultasSource.getInstance().getConsultasMessagesSetupKey("ErrorSistema"), true);
//		this.getSessionBeanEstadoOrdenProceso().setRenderedMensajeAlertGridPanel(true);
//	    }
	    
	}

    }  
   //el nombre del metodo esta mal, el movimiento es de Distribucion a Retencion
   public void generarBaseRetencionADistribucion(List pListNumOrden) {
        BaseBaseEmDAO dao = (BaseBaseEmDAO) this.getFactoryDAO().getBaseEmDAO();
	for(Iterator it=pListNumOrden.iterator();it.hasNext();){ 
	    String pNumOrden=(String)it.next();
	    try {           
			String strNormal=ConstantesGenerales.DESC_BASE_EM_NOCLASS;
			String codigoBase_=ConstantesGenerales.TIPO_BASE_EM_NOCLASS;
			HashMap hashBase_=(HashMap)dao.debeGenerarBaseEM(pNumOrden);	
			if(hashBase_!=null){
			    for(Iterator itHash=hashBase_.keySet().iterator();itHash.hasNext();){
				String key_=(String)itHash.next();
				ArrayList baseList_=(ArrayList)hashBase_.get(key_);		
				String[] splitArray_=key_.split("-");
				if(splitArray_.length==2 && baseList_.size()>0){
				    String numOrden_=splitArray_[0];
				    String codigoNodo_=splitArray_[1];
				    this.crearExcelBase(baseList_, numOrden_, codigoNodo_, strNormal,codigoBase_);
				}
			    }
			}
	    }catch (Exception e){		
		e.printStackTrace();
	      //  throw new NoClassException("NoClassHelper:clasificarEnvios: " + e.toString());
	    }
	}
    }  
}